Un projet en science des données comprends trois grandes étapes. D’abord, vous devez collecter des données et vous les compilez adéquatement. Cela peut consister à télécharger des données existantes, exécuter un dispositif expérimental ou effectuer une recensement (étude observationnelle). Compiler les données dans un format qui puisse être importé est une tâche souvent longue et fastidieuse. Puis, vous investiguez les données collectées, c’est-à-dire vous les visualisez, vous appliquez des modèles et testez des hypothèses. Enfin, la communication des résultats consiste à présenter les connaissances qui émerge de votre analyse sous forme visuelle et narrative, avec un langage adapté à la personne qui vous écoute, qu’elle soit experte ou novice, réviseure de revue savante ou administratrice. Grolemund et Wickham (2018) propose la structure d’analyse suivante, avec de légères modifications de ma part.
Le grand cadre spécifie Programmer. Oui, vous aurez besoin d’écrire du code. Mais comme je l’ai indiquer dans le premier chapitre, ceci n’est pas un cours de programmation et je préférerai les approches intuitives.
À la fin de ce chapitre, vous devrez:
Selon Whitlock et Schluter (2015), la statistique est l’étude des méthodes pour décrire et mesurer des aspects de la nature à partir d’échantillon. Pour Grolemund et Wickham (2018), la science des données est une discipline exitante permettant de transformer des données bruttes en compréhension, perspectives et connaissances. Oui, exitante! La différence entre les deux champs d’expertise est subtile, et certaines personnes n’y voient qu’une différence de ton.
Data Science is statistics on a Mac.
— Big Data Borat (@BigDataBorat) 27 août 2013
Confinées à ses applications traditionnelles, les statistiques sont davantage vouées à la définition de dispositifs expérimentaux et à l’exécution de tests d’hypothèses, alors que la science des données est moins linéaire, en particulier dans sa phase d’analyse, où de nouvelles questions (donc de nouvelles hypothèses) peuvent être posées au fur et à mesure de l’analyse. Cela arrive généralement davantage lorsque l’on fait face à de nombreuses observations sur lesquelles ne nombreux paramètres sont mesurés.
La quantité de données et de mesures auquelles nous avons aujourd’hui accès grâce aux technologies de mesure et de stockage relativement peu dispendieux rend la science des données une discipline particulièrement attrayante, pour ne pas dire sexy.
R est la 18ième lettre de l’alphabet latin. Mais R est un langage de programmation dérivé du langage S, qui fut initialement lancé en 1976.
R figure parmi les langages de programmation les plus utilisés au monde. Bien qu’il soit basé sur les langages statiques C et Fortran, R est un langage dynamique, c’est à dire que le code peut être exécuté ligne par ligne ou bloc par bloc: un avantage majeur pour des activités qui nécessitent des intéractions fréquentes. Bien que R soit surtout utilisé pour le calcul statistique, il s’impose de plus en plus comme outil privilégié en sciences des données en raison des récents développements de modules d’analyse, de modélisation et de visualisation, dont plusieurs seront utilisés dans ce manuel.
Il existe de nombreuses manières d’utiliser R. Parmi celles-ci, j’en couvrirai 3:
Sur Windows ou Mac, dirigez-vous ici, téléchargez et installez. Sur Linux, ouvrez votre gestionnaire d’application, chercher r-base (Ubuntu, Debian), R-base (openSuse) ou R-core (Fedora) et installez-le (asurez-vous que les librairies suivantes sont aussi installées: gcc, gcc-fortran, gcc-c++ et make), vous aurez peut-être besoin d’installer des librairies supplémentaires pour faire fonctionner certains modules.
Note. Les modules présentés dans ce cours devraient être disponibles sur Linux, Windows et Mac. Ce n’est pas le cas pour tous les modules R. La plupart fonctionnent néanmoins sur Linux, dont les systèmes d’opération (je recommande Ubuntu ou l’une de ses dérivées) sont de bonnes options pour le calcul scientifique.
À cette étape, R devrait fonctionner dans un interprétateur de commande . Si vous lancez R dans un terminal (chercher cmd dans le menu si vous êtes sur Windows), vous obtiendrez quelque chose comme ceci.
Le symbole > indique que R attend que vos instructions. Vous voilà dans un état méditatif devant l’indéchiffrable vide du terminal. Afin de travailler dans un environnement de travail plus convivial, je recommande l’installation de l’interface RStudio, gratuite et open source: téléchargez l’installateur et suivez les intructions. RStudio ressemble à ceci.
En haut à droite se trouve un menu Project (None). Il s’agit d’un menu de vos projets. Je recommande d’utiliser ces projets avec RStudio, qui vous permettront de mieux gérer vos environnements de travail, en particulier en lien avec les chemins vers de vos données, graphiques, etc., que vous pouvez gérer relativement à l’emplacement de votre dossier de projet plutôt qu’à l’emplacement des fichiers sur votre machine.
F1). Enfin, l’onglet Viewer affichera les sorties HTML, en particulier les graphiques intéractifs que vous générerez par exemple avec le module plotly.Les R notebooks offrent une approche de programmation littéraire, c’est-à-dire que vous écrivez votre code comme vous écrivez une article, une thèse ou une histoire. Cette approche permet de partager plus facilement vos codes, que ce soit avec une équipe de travail ou à la communauté scientifitque pour accompagner un article scientifique en tant que matériel supplémentaire. Lorsque vous créez un notebook (File > New file > R notebook), les instructions de base apparaissent. Ajoutons que pour lancer du code ligne par ligne, vous pouvez surligner le code en question ou placez le curseur sur la ligne à exécuter, puis taper Ctrl + Enter. La sortie de R apparaîtra sous le bloc de code. Dans votre texte, vous pouvez ajouter des équations mathématiques en format Mathjax inspiré du format Latex, par exemple $a = \sum_{i=1}^n x_i^2$ sera affiché comme \(a = \sum_{i=1}^n x_i^2\) (pour aider dans l’édition d’équation, vous pouvez utiliser un éditeur dans les nuages). Pour les titres, les caractères gras, l’insertion d’image, les hyper-liens, les tableaux, etc., référez-vous à la documentation de Markdown.
Si votre environnement de travail était un avion, R serait le moteur et RStudio serait le cockpit!
Si vous cherchez une trousse complète d’analyse de données, comprenant R et Python, vous pourrez préférer Anaconda. Une fois installée, vous pourrez isoler une environnement de travail sur R, ou même isoler des environnements de travail particuliers pour vos projets. Une manière conviviale de créer des environnements de travail est de passer par l’interface Anaconda navigator, que vous lancerez soit dans le menu Windows, soit en ligne de commande anaconda-navigator sous Mac et Linux, puis d’installer r-essentials, rstudio et jupyterlab dans l’onglet Environment. Vous pourrez aussi installer RStudio et Jupyter lab via l’onglet Home de Anaconda navigator. Dans l’environnement de base, installez le package nb_conda_kernels pour vous assurer que tous les noyaux (R, Python, etc.) installés dans les environnements de travail soient automatiquement accessibles dans Jupyter.
Jupyter lab est une interface notebook semblable à R notebook. C’est justement sous Jupyter lab qu’est rédigé ce document. À vrai dire, l’utilisation de R en Anaconda n’est pas tout à fait au point, et pourrait poser problème pour l’installation de certains modules. Si vous optez pour cette option, préparez-vous à avoir à bidouiller un peu.
Microsoft rend disponible gratuitement un service de notebook en ligne nommé Azure notebooks. Vous y aurez accès avec un compte Exchange (par exemple, votre IDUL de l’Université Laval) ou bien avec un compte Microsoft (Outlook, Skype, Hotmail, etc.). Microsoft Azure fonctionne avec Anaconda, et hérite de certaines difficultés à installer des packages. Avantages majeurs: tout fonctionne dans les nuages, donc (1) vous pouvez obtenir des performances intéressantes même si avec un processeur agé ou bas de gamme et (2) vous n’avez rien à installer sur votre machine. Désavantages majeurs: (1) vous devez être conecté à internet et (2) vous devrez installer vos modules à chaque fois que vous vous connecterez pour débuter une session de calcul. Apparamment, l’option de travail collaboratif sur un même notebook est en cours de développement.
R ne fonctionne pas avec des menus, en faisant danser une souris sous une musique de clics. Vous devrez donc entrer des commandes avec votre clavier, que vous apprendrez par coeur au fur et à mesure, ou que vous retrouverez en lançant des recherches sur internet. Par expérience personnelle, lorsque je travaille avec R, j’ai toujours un navigateur ouvert prêt à recevoir une question.
Les étapes qui suivent sont des premiers pas. Elles ne feront pas de vous des ceintures noires dela prorgammation. La plupart des utilisateurs de R ont appris R en se pratiquant sur leurs données, en frappant des murs, en apprenant comment les escalader ou les contourner…
Pour l’instant, ouvrez seulement un interprétateur de commande, et lancez R. Voyons si R est aussi libre qu’on le prétend.
“La liberté, c’est la liberté de dire que deux et deux font quatre. Si cela est accordé, tout le reste suit.” - George Orwell, 1984
2 + 2
## [1] 4
Et voilà.
Les opérations mathématiques sont effectuées telles que l’on devrait s’attendre.
67.1 - 43.3
## [1] 23.8
2 * 4
## [1] 8
1 / 2
## [1] 0.5
L’exposant peut être noté ^, comme c’est le cas dans Excel, ou ** comme c’est le cas en Python.
2^4
## [1] 16
2**4
## [1] 16
1 / 2 # utilisez des espaces de part et d'autre des opérateurs (sauf pour l'exposant) pour éclaircir le code
## [1] 0.5
R ne lit pas ce qui suit le caractère #. Cela vous laisse l’opportunité de commenter un code comprenant une qéquence de plusieurs lignes. Remarquez également que la dernière opération comporte des espaces entre les nombres et l’opérateur /. Dans ce cas (ce n’est pas toujours le cas), les espaces ne signifient rien: ils aident seulement à éclaircir le code. Il existe des guides pour l’écriture de code en R. Je recommande le guide de style de Hadley Wickahm.
Assigner des objets à des variables est fondamental en programmation. En R, on assigne traditionnellement avec la flèche <-, mais vous verrez parfois le =, quiest davantage utilisé comme standard dans d’autres langages de programmation. Par exemple.
a <- 3
Techniquement, a pointe vers le nombre entier 3. Conséquemment, on peut effectuer des opérations sur a.
a * 6
## [1] 18
#A + 2
Le message d’erreur nous dit que A n’est pas défini. Sa version minuscule, a, l’est pourtant. La raison est que R considère la case dans la définition des objets. Utiliser la mauvaise case mène donc à des erreurs.
Note. Les messages d’erreur ne sont pas toujours clairs, mais vous apprendrez à les comprendre. Dans tous les cas, ils sont fait pour vous aider. Lisez-les attentivement!
En général, le nom d’une variable doit toujours commencer par une lettre, et ne doit pas contenir de caractères réservés (espaces, +, *). Dans la définition des variables, plusieurs utilisent des symboles . pour délimiter les mots, mais la barre de soulignement _ est à préférer. En effet, dans d’autres langages de programmation comme Python, le . a une autre signification: son utilisation est à éviter autant que possible.
Note. À ce stade, vous serez probablement plus à l’aise de copier-coller ces commandes dans votre terminal.
rendement_arbre <- 50 # pomme/arbre
nombre_arbre <- 300 # arbre
nombre_pomme <- rendement_arbre * nombre_arbre
nombre_pomme
## [1] 15000
Comme chez la plupart des langages de prorgammation, R respecte les conventions des priorités des opérations mathéatiques.
10 - 9^0.5 * 2
## [1] 4
Jusqu’à maintenant, nous n’avons utilisé que des nombres entiers (integer ou int) et des nombres réels (numeric ou float64). R inclut d’autres types. La chaîne de caractère (string ou character) contient un ou plusieurs symboles. Elle est définie entre des double-guillemets " " ou des apostrophes ' '. Il n’existe pas de standard sur l’utilisation de l’un ou de l’autre, mais en règle générale, on utilise les apostrophe pour les experssions courtes, contenant un simple mot ou séquence de lettres, et les guillements pour les phrases. Une raison pour cela: les guillemets sont utiles pour insérer des apostrophes dans une chaîne de caractère.
a <- "L'ours"
b <- "polaire"
paste(a, b)
## [1] "L'ours polaire"
On colle a et b avec la fonction paste. Notez que l’objet a a été défini précédemment. Il est possible en R de réassigner une variable, mais cela peut porter à confusion, jusqu’à générer des erreurs de calcul si une variable n’est pas assigné à l’objet auquel on voulait référer.
Combien de caractères contient la chaîne "L'ours polaire"? R sait compter. Demandons-lui.
c <- paste(a, b)
nchar(c)
## [1] 14
Quatorze, c’est bien cela (comptez “L’ours polaire”, en incluant l’espace). Comme paste, nchar est une fonction incluse par défaut dans l’environnement de travail de R: plus précisément, ces fonctions sont incluses dans le module base, inclut par défaut lorsque R est lancé. La fonction est appelée en écrivant nchar(). Mais une fonction de quoi? Des arguments, qui se trouvent entre les parenthèses. Dans ce cas, il y a un seul argument: c.
En calcul scientifique, il est courrant de lancer des requêtes sur si une résultat est vrai ou faux.
a <- 17
a < 10
## [1] FALSE
a > 10
## [1] TRUE
a == 10
## [1] FALSE
a != 10
## [1] TRUE
a == 17
## [1] TRUE
!(a == 17)
## [1] FALSE
Je viens d’introduire un nouveau type de donnée: les données booléennes (boolean, ou logical), qui ne peuvent prendre que deux états - TRUE ou FALSE. En même temps, j’ai utilisé la fonction print parce que dans mon carnet, seule la dernière opération permet d’afficher le résultat. Si l’on veut forcer une sortie, on utilise print. Puis, on a vu plus haut que le symbole = est réservé pour assigner des objets: pour les tests d’égalité, on utilise le double égal, ==, ou != pour la non égalité. Enfin, pour inverser une donnée de type booléenne, on utilise le point d’exclamation !.
Les exercices précédents ont permis de présenter les types de données offerts par défault sur R qui sont les plus importants pour le calcul scientifique: int (integer, ou nombre entier), numeric (nombre réel), character (string, ou chaîne de caractère) et logical (booléen). D’autres s’ajouterons tout au long du cours, comme les catégories (factor) et les unités de temps (date-heure).
Lorsque l’on procède à des opérations de calcul en science, nous utilisons rarement des valeurs uniques. Nous préférons les organiser et les traiter en collections. Par défaut, R offre quatre types importants de collections: les vecteurs, les matrices, les listes et les tableaux.
D’abord, les vecteurs sont une série de variables de même type. Un vecteur est délimité par la fonction c( ) (c pour concaténation). Les éléments de la liste sont séparés par des virgules.
espece <- c('Petromyzon marinus', 'Lepisosteus osseus', 'Amia calva', 'Hiodon tergisus')
espece
## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"
## [4] "Hiodon tergisus"
Pour accéder aux éléments d’une liste, appelle la liste suivie de la position de l’objet désiré entre crochets.
espece[1]
## [1] "Petromyzon marinus"
espece[2]
## [1] "Lepisosteus osseus"
espece[1:3]
## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"
espece[c(1, 3)]
## [1] "Petromyzon marinus" "Amia calva"
On peut noter que le premier élément de la liste est noté 1, et non 0 comme c’est le cas de la plupart de langages. Le raccourcis 1:3 crée une liste de nombres entiers de 1 à 3 inclusivement, c’est-à-dire l’équivalent de c(1, 2, 3). En effet, on crée une liste d’indices pour soutirer des éléments d’une liste. On peut utiliser le symbole de soustraction pour retirer un ou plusieurs éléments d’un vecteur.
espece[-c(1, 3)]
## [1] "Lepisosteus osseus" "Hiodon tergisus"
Pour ajouter un élément à notre liste, on peut utiliser la fonction c( ).
espece <- c(espece, "Cyprinus carpio")
espece
## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"
## [4] "Hiodon tergisus" "Cyprinus carpio"
Notez que l’on efface l’objet espece par une contaténation de l’objet espece, précédemment défini, et d’un autre élément.
En lançant espece[3] <- "Lepomis gibbosus", il est possible de changer une élément de la liste.
espece[3] <- "Lepomis gibbosus"
espece
## [1] "Petromyzon marinus" "Lepisosteus osseus" "Lepomis gibbosus"
## [4] "Hiodon tergisus" "Cyprinus carpio"
Une matrice est un vecteur de dimension plus élevée que 1. En écologie, on dépasse rarement la deuxième dimension, quoi que les matrices en N dimensions soient courrantes en modélisation mathématique. Je ne considérerai pour le moment que des matrices 2D. Comme c’est la cas des vecteurs, les matrices contiennent des valeurs de même type. En R, on peut attribuer aux matrices 2D des noms de ligne et de colonne.
mat <- matrix(c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), ncol=3)
mat
## [,1] [,2] [,3]
## [1,] 1 5 9
## [2,] 2 6 10
## [3,] 3 7 11
## [4,] 4 8 12
colnames(mat) <- c('A', 'B', 'C')
rownames(mat) <- c('site_1', 'site_2', 'site_3', 'site_4')
mat
## A B C
## site_1 1 5 9
## site_2 2 6 10
## site_3 3 7 11
## site_4 4 8 12
On peut soutirer les noms de colonne et les noms de ligne. Le résultat est un vecteur.
colnames(mat)
## [1] "A" "B" "C"
rownames(mat)
## [1] "site_1" "site_2" "site_3" "site_4"
Les listes sont des collections hétérogènes dans lesquelles on peut placer les objets désirés, sans distinction: elles peuvent même inclure d’autres listes. Chacun des éléments de la liste peut être identifié par une clé.
ma_liste <- list(especes = c('Petromyzon marinus', 'Lepisosteus osseus',
'Amia calva', 'Hiodon tergisus'),
site = 'A101',
stations_meteos = c('746583', '783786', '856363'))
ma_liste
## $especes
## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"
## [4] "Hiodon tergisus"
##
## $site
## [1] "A101"
##
## $stations_meteos
## [1] "746583" "783786" "856363"
Les éléments de la liste peuvent être soutirés par le nom de la clé ou par l’indice, de cette mannière.
ma_liste$especes
## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"
## [4] "Hiodon tergisus"
ma_liste[[1]]
## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"
## [4] "Hiodon tergisus"
Exercice. Accéder au deuxième élément du vecteur d’espèces dans la liste ma_liste.
Enfin, le type de collection de données le plus important est le tableau, ou data.frame. Techniquement, il s’agit d’une liste composée de vecteurs de même longueur. Chaque colonne peut ainsi prendre un type de donnée indépendamment des autres colonnes.
tableau <- data.frame(espece = c('Petromyzon marinus', 'Lepisosteus osseus',
'Amia calva', 'Hiodon tergisus'),
poids = c(10, 13, 21, 4),
longueur = c(35, 44, 50, 8))
tableau
En programmation classique en R (nous verrons plus loin la méthode tidyverse), les éléments d’un tableau se manipulent comme ceux d’une matrice et les colonnes peuvent être appelés comme les éléments d’une liste.
tableau[, 2:3]
tableau$poids
## [1] 10 13 21 4
Vous verrez aussi, quoi que rarement, ce format, qui à la différence du format $ génère un tableau.
tableau['poids']
Le tableau est le format de collection à privilégier pour manipuler des données. Récemment, le format de tableau tibble a été créé par l’équipe de RStudio pour offrir un format plus moderne.
Lorsque vous écrivez une commande suivit de parenthèses, comme data.frame(especes = ...), vous demandez à R de passer à l’action en appelant une fonction. De manière très générale, une fonction transforme quelque chose en quelque chose d’autre.
Par exemple, la fonction mean() prend une collection de nombre comme entrée, puis en sort vous devinez quoi.
mean(tableau$poids)
## [1] 12
Les entrées sont appelés les arguments de la fonction. Leur définition est toujours disponible dans la documentation.
Exercice. Familiarisez-vous avec la documentation de R en lançant ?mean. Truc: si vous avez pris de l’avance et que vous travaillez déjà en RStudio, mettez le terme en surbrillance, puis appuyez sur F1.
Vous verrez dans la documentation que la fonction mean() demande trois arguments, x, trim et na.rm. Or nous avons seulement placé un vecteur, sans spécifier d’argument!
En effet. En l’absence d’une définition des arguments, R supposera que les arguments dans la parenthèse, séparés par une virgule, sont présentés dans le même ordre que celui spécifié dans la définition de la fonction (celle qui est présentée dans le fichier d’aide). Dans le cas qui nous intéresse, mean(tableau$poids) est équivalent à mean(x = tableau$poids).
Maintenant, selon la fiche d’aire l’argument na.rm est un valeur logique spécifiant si oui (TRUE) ou non (FALSE) les valeurs manquantes doivent être considérées (une moyenne d’un vecteur comprenant au moins un NA sera de NA). En ne spécifiant rien, R prend la valeur par défaut, telle que spécifiée dans la documentation. Il en va de même que l’argument trim, qui permet d’élaguer des valeurs extrêmes. Dans la fiche d’aide, mean(x, trim = 0, na.rm = FALSE, ...) signifie que par défaut, l’argument x est vide (il doit donc être spécifié), l’argument trim est de 0 et l’argument na.rm est FALSE.
mean(c(6, 1, 7, 4, 9, NA, 1))
## [1] NA
mean(c(6, 1, 7, 4, 9, NA, 1), na.rm = TRUE)
## [1] 4.666667
Vous n’êtes pas emprisonné par les fonctions offertes par R. Vous pouvez installer des modules qui complètent les fonctions de base de R: on le verra un peu plus loin dans ce chapitre. Mais pour l’instant, voyons comment vous pouvez créer vos propres fonctions. Disons que vous voulez créer une fonction qui calcule la sortie de \(x^3-2y+a\). Pour obtenir la réponse on a besoin des arguments x, y et a. La sortie de la fonction est ici triviale: la réponse de l’équation. L’opération function permet de prendre ça en charge.
operation_f <- function(x, y, a = 10) {
return(x^3-2*y+a)
}
Notez que a a une valeur par défaut. La sortie de la fonction est ce qui se trouve entre les parenthèses de return. Vous pouvez maintenant utiliser la fonction operation_nl au besoin.
operation_f(x = 2, y = 3, a = 1)
## [1] 3
Une telle fonction est peu utile. Mais l’utilisation de fonctions personnalisées vous permettra d’éviter de répéter la même opération plusieurs fois dans un flux de travail, en évitant de générer trop de code, donc aussi de potentielles erreurs. Personnellement, j’utilise les fonctions surtout pour générer des graphiques personnalisés.
Exercice. Afin d’acquérir de l’autonomie, vous devrez être en mesure de trouver le nom des commandes dont vous avez besoin pour effectuer la tâche que vous désirer effectuer. Cela peut causer des frustrations, mais vous vous sentirez toujours plus à l’aise vec R jour après jour. L’exercice ici est de trouver par vous-même la commande qui vous permettra mesurer la longueur d’un vecteur.
Les boucles permettent d’effectuer une même suite d’opérations sur plusieurs objets. Pour faire suite à notre exemple, nous désirons obtenir le résultat de l’opération f pour des paramètres que nous enregistrons dans ce tableau.
params <- data.frame(x = c(2, 4, 1, 5, 6),
y = c(3, 4, 8, 1, 0),
a = c(6, 1, 8, 2, 5))
params
Nous créons un vecteur vide, puis nous itérons ligne par ligne en remplissant le vecteur.
operation_res <- c()
for (i in 1:nrow(params)) {
operation_res[i] <- operation_f(x = params[i, 1], y = params[i, 2], a = params[i, 3])
}
operation_res
## [1] 8 57 -7 125 221
En faisant varier i sur des valeurs du vecteur donné par la séquence de nombre entiers de 1 au nombre de ligne du tableau de paramètres, nous demandons à R d’effectuer la suite d’opération entre les accolades {}. À chaque boucle, i prend une valeur de la séquence. i est utilisé ici comme indice de la ligne à soutirer du tableau params, qui correspond à l’indice dans le vecteur operation_res.
Ainsi, chaque résultat est calculé dans l’ordre des lignes du tableau de paramètres et l’on pourra très bien y coller nos résultats:
params$resultats <- operation_res
params
Notez que puisque la colonne resultat n’existe pas dans le tableau params, R crée automatiquement une nouvelle colonne.
Les boucles for vous permettront par exemple de générer en peu de temps 10, 100, 1000 graphiques (autant que vous voulez), chacun issu de simulations obtenues à partir de conidtions initiales différentes, et de les enregistrer dans un répertoire sur votre ordinateur. Un travail qui pourrait prendre des semaines sur Excel peut être effectué en R en quelques secondes.
Un second outil est disponible pour les itérations: les boucles while. Elles effectue une opération tant qu’un critère n’est pas atteint. Elles sont utiles pour les opérations où l’on cherche une convergence. Je les couvre rapidement puisque’elles sont rarement utilisées dans les flux de travail courrants. En voici un petit exemple.
x <- 100
while (x > 1.1) {
x <- sqrt(x)
print(x)
}
## [1] 10
## [1] 3.162278
## [1] 1.778279
## [1] 1.333521
## [1] 1.154782
## [1] 1.074608
Nous avons inité x à une valeur de 100. Puis, tant que (while) le test x > 1.1 est vrai, attribuer à x la nouvelle valeur calculée en extrayant la racine de la valeur précédente de x. Enfin, indiquer la valeur avec print.
Si la condition 1 est remplie, effectuer une suite d’instruction 1. Si la condition 1 n’est pas remplie, et si la condition 2 est remplie, effectuer la suite d’instruction 2. Sinon, effectuer la suite d’instruction 3.
Voilà comment on exprime une suite de conditions. Prenons l’exemple simple d’une discrétisation d’une valeur continue. Si \(x<10\), il est classé comme faible. Si \(10 \leq x <20\), il est classé comme moyen. Si \(x \geq 20\), il est classé comme élevé. Plaçons cette classification dans une fonction.
classification <- function(x, lim1=10, lim2=20) {
if (x < lim1) {
categorie <- "faible"
} else if (x < lim2) {
categorie <- "moyen"
} else {
categorie <- "élevé"
}
return(categorie)
}
classification(-10)
## [1] "faible"
classification(15.4)
## [1] "moyen"
classification(1000)
## [1] "élevé"
Une condition est définie avec le if, suivi du test à vrai ou faux entre parenthèse. Si le test retourne un vrai (TRUE), l’instruction entre accolades est exécutée. Si elle est fausse, on passe au suivant.
Exercice. Explorer les commandes ifelse et cut et réfléchissez à la manière qu’ils pourraient être utilées pour effectuer une discrétisation plus efficacement qu’avec les if et les else.
La plupart des opérations d’ordre général (comme les racines carrées, les tests statistiques, la gestion de matrices et de tableau, les graphiques, etc.) sont accessibles grâce aux modules de base de R, qui sont installés et chargés par défaut lors du démarrage de R. Des équipes de travail ont néanmoins développé plusieurs modules pour répondre à leurs besoins spécialisés, et les ont laissées disponibles au grand public dans des modules que vous pouvez installer d’un dépôt CRAN (le AppStore de R), d’un dépôt Anaconda (le AppStore de Anaconda, si vous utilisez cette plate-forme), d’un dépôt Github (dépôts décentralisés), etc.
RStudio possède un pratique bouton Install qui vous permet d’y inscrire une liste de modules. Le navigateur anaconda offre aussi une interface d’installation. La commande R pour installer un module est install.packages("ggplot2"), si par exemple vous désirez installer ggplot2, le module graphique par excellence en R. C’est la commande que RStudio lancera tout seul si vous lui demandez d’installer ggplot2.
Les modules sont l’équivalent des applications spécialisées que vous installez sur un téléphone mobile. Pour les utiliser, il faut les ouvir.
Généralement, j’ouvre toutes les applications nécessaires à mon flux de travail au tout début de ma feuille de calcul (la prochaine cellule retournera un message d’erreur si les packages ne sont pas installés).
library("tidyverse") # méta-package qui charge entre autres dplyr et ggplot2
## ── Attaching packages ───────────────────────────────────────────────────────────────────────────── tidyverse 1.2.1 ──
## ✔ ggplot2 3.1.0 ✔ purrr 0.2.5
## ✔ tibble 1.4.2 ✔ dplyr 0.7.7
## ✔ tidyr 0.8.2 ✔ stringr 1.3.1
## ✔ readr 1.1.1 ✔ forcats 0.3.0
## ── Conflicts ──────────────────────────────────────────────────────────────────────────────── tidyverse_conflicts() ──
## ✖ dplyr::filter() masks stats::filter()
## ✖ dplyr::lag() masks stats::lag()
library("vegan")
## Loading required package: permute
## Loading required package: lattice
## This is vegan 2.5-3
library("nlme")
##
## Attaching package: 'nlme'
## The following object is masked from 'package:dplyr':
##
## collapse
Les modules sont installés sur votre ordinateur à un endroit que vous pourrez retrouver avec la commande .libPaths()
Exercice. À partir d’ici jusqu’à la fin du cours, nous utiliserons RStudio. Ouvrez-le et familiarisez-vous avec l’interface! Quelques petits trucs:
tidyverseComme une langue, on n’apprend à s’exprimer en un langage informatique qu’en se mettant à l’épreuve, ce que vous ferez tout au long de ce cours. Pour vous encourager, voici quelques trucs pour apprendre à coder en R.